/*
 * Copyright (c) 2007-2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.sun.org.apache.bcel.internal.generic;

/* ====================================================================
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2001 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" and
 *    "Apache BCEL" must not be used to endorse or promote products
 *    derived from this software without prior written permission. For
 *    written permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache",
 *    "Apache BCEL", nor may "Apache" appear in their name, without
 *    prior written permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */

import com.sun.org.apache.bcel.internal.Constants;
import com.sun.org.apache.bcel.internal.classfile.*;
import java.util.*;

/**
 * Template class for building up a method. This is done by defining exception
 * handlers, adding thrown exceptions, local variables and attributes, whereas
 * the `LocalVariableTable' and `LineNumberTable' attributes will be set
 * automatically for the code. Use stripAttributes() if you don't like this.
 *
 * While generating code it may be necessary to insert NOP operations. You can
 * use the `removeNOPs' method to get rid off them.
 * The resulting method object can be obtained via the `getMethod()' method.
 *
 * @author  <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
 * @author  <A HREF="http://www.vmeng.com/beard">Patrick C. Beard</A> [setMaxStack()]
 * @see     InstructionList
 * @see     Method
 */
public class MethodGen extends FieldGenOrMethodGen {
    private String class_name;
    private Type[] arg_types;
    private String[] arg_names;
    private int max_locals;
    private int max_stack;
    private InstructionList il;
    private boolean strip_attributes;

    private ArrayList variable_vec = new ArrayList();
    private ArrayList line_number_vec = new ArrayList();
    private ArrayList exception_vec = new ArrayList();
    private ArrayList throws_vec = new ArrayList();
    private ArrayList code_attrs_vec = new ArrayList();

    /**
     * Declare method. If the method is non-static the constructor
     * automatically declares a local variable `$this' in slot 0. The
     * actual code is contained in the `il' parameter, which may further
     * manipulated by the user. But he must take care not to remove any
     * instruction (handles) that are still referenced from this object.
     *
     * For example one may not add a local variable and later remove the
     * instructions it refers to without causing havoc. It is safe
     * however if you remove that local variable, too.
     *
     * @param access_flags access qualifiers
     * @param return_type  method type
     * @param arg_types argument types
     * @param arg_names argument names (if this is null, default names will be provided
     * for them)
     * @param method_name name of method
     * @param class_name class name containing this method (may be null, if you don't care)
     * @param il instruction list associated with this method, may be null only for
     * abstract or native methods
     * @param cp constant pool
     */
    public MethodGen(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name, String class_name, InstructionList il, ConstantPoolGen cp) {
        setAccessFlags(access_flags);
        setType(return_type);
        setArgumentTypes(arg_types);
        setArgumentNames(arg_names);
        setName(method_name);
        setClassName(class_name);
        setInstructionList(il);
        setConstantPool(cp);

        boolean abstract_ = isAbstract() || isNative();
        InstructionHandle start = null;
        InstructionHandle end = null;

        if (!abstract_) {
            start = il.getStart();
            end = il.getEnd();

            /* Add local variables, namely the implicit `this' and the arguments
             */
            if (!isStatic() && (class_name != null)) { // Instance method -> `this' is local var 0
                addLocalVariable("this", new ObjectType(class_name), start, end);
            }
        }

        if (arg_types != null) {
            int size = arg_types.length;

            for (int i = 0; i < size; i++) {
                if (Type.VOID == arg_types[i]) {
                    throw new ClassGenException("'void' is an illegal argument type for a method");
                }
            }

            if (arg_names != null) { // Names for variables provided?
                if (size != arg_names.length)
                    throw new ClassGenException("Mismatch in argument array lengths: " + size + " vs. " + arg_names.length);
            } else { // Give them dummy names
                arg_names = new String[size];

                for (int i = 0; i < size; i++)
                    arg_names[i] = "arg" + i;

                setArgumentNames(arg_names);
            }

            if (!abstract_) {
                for (int i = 0; i < size; i++) {
                    addLocalVariable(arg_names[i], arg_types[i], start, end);
                }
            }
        }
    }

    /**
     * Instantiate from existing method.
     *
     * @param m method
     * @param class_name class name containing this method
     * @param cp constant pool
     */
    public MethodGen(Method m, String class_name, ConstantPoolGen cp) {
        this(m.getAccessFlags(), Type.getReturnType(m.getSignature()), Type.getArgumentTypes(m.getSignature()), null /* may be overridden anyway */, m.getName(), class_name, ((m.getAccessFlags() & (Constants.ACC_ABSTRACT | Constants.ACC_NATIVE)) == 0) ? new InstructionList(m.getCode().getCode()) : null, cp);

        Attribute[] attributes = m.getAttributes();
        for (int i = 0; i < attributes.length; i++) {
            Attribute a = attributes[i];

            if (a instanceof Code) {
                Code c = (Code) a;
                setMaxStack(c.getMaxStack());
                setMaxLocals(c.getMaxLocals());

                CodeException[] ces = c.getExceptionTable();

                if (ces != null) {
                    for (int j = 0; j < ces.length; j++) {
                        CodeException ce = ces[j];
                        int type = ce.getCatchType();
                        ObjectType c_type = null;

                        if (type > 0) {
                            String cen = m.getConstantPool().getConstantString(type, Constants.CONSTANT_Class);
                            c_type = new ObjectType(cen);
                        }

                        int end_pc = ce.getEndPC();
                        int length = m.getCode().getCode().length;

                        InstructionHandle end;

                        if (length == end_pc) { // May happen, because end_pc is exclusive
                            end = il.getEnd();
                        } else {
                            end = il.findHandle(end_pc);
                            end = end.getPrev(); // Make it inclusive
                        }

                        addExceptionHandler(il.findHandle(ce.getStartPC()), end, il.findHandle(ce.getHandlerPC()), c_type);
                    }
                }

                Attribute[] c_attributes = c.getAttributes();
                for (int j = 0; j < c_attributes.length; j++) {
                    a = c_attributes[j];

                    if (a instanceof LineNumberTable) {
                        LineNumber[] ln = ((LineNumberTable) a).getLineNumberTable();

                        for (int k = 0; k < ln.length; k++) {
                            LineNumber l = ln[k];
                            addLineNumber(il.findHandle(l.getStartPC()), l.getLineNumber());
                        }
                    } else if (a instanceof LocalVariableTable) {
                        LocalVariable[] lv = ((LocalVariableTable) a).getLocalVariableTable();

                        removeLocalVariables();

                        for (int k = 0; k < lv.length; k++) {
                            LocalVariable l = lv[k];
                            InstructionHandle start = il.findHandle(l.getStartPC());
                            InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());

                            // Repair malformed handles
                            if (null == start) {
                                start = il.getStart();
                            }

                            if (null == end) {
                                end = il.getEnd();
                            }

                            addLocalVariable(l.getName(), Type.getType(l.getSignature()), l.getIndex(), start, end);
                        }
                    } else if (a instanceof LocalVariableTypeTable) {
                        LocalVariable[] lv = ((LocalVariableTypeTable) a).getLocalVariableTypeTable();
                        removeLocalVariables();
                        for (int k = 0; k < lv.length; k++) {
                            LocalVariable l = lv[k];
                            InstructionHandle start = il.findHandle(l.getStartPC());
                            InstructionHandle end = il.findHandle(l.getStartPC() + l.getLength());
                            // Repair malformed handles
                            if (null == start) {
                                start = il.getStart();
                            }
                            if (null == end) {
                                end = il.getEnd();
                            }
                            addLocalVariable(l.getName(), Type.getType(l.getSignature()), l.getIndex(), start, end);
                        }
                    } else
                        addCodeAttribute(a);
                }
            } else if (a instanceof ExceptionTable) {
                String[] names = ((ExceptionTable) a).getExceptionNames();
                for (int j = 0; j < names.length; j++)
                    addException(names[j]);
            } else
                addAttribute(a);
        }
    }

    /**
     * Adds a local variable to this method.
     *
     * @param name variable name
     * @param type variable type
     * @param slot the index of the local variable, if type is long or double, the next available
     * index is slot+2
     * @param start from where the variable is valid
     * @param end until where the variable is valid
     * @return new local variable object
     * @see LocalVariable
     */
    public LocalVariableGen addLocalVariable(String name, Type type, int slot, InstructionHandle start, InstructionHandle end) {
        byte t = type.getType();

        if (t != Constants.T_ADDRESS) {
            int add = type.getSize();

            if (slot + add > max_locals)
                max_locals = slot + add;

            LocalVariableGen l = new LocalVariableGen(slot, name, type, start, end);
            int i;

            if ((i = variable_vec.indexOf(l)) >= 0) // Overwrite if necessary
                variable_vec.set(i, l);
            else
                variable_vec.add(l);

            return l;
        } else {
            throw new IllegalArgumentException("Can not use " + type + " as type for local variable");

        }
    }

    /**
     * Adds a local variable to this method and assigns an index automatically.
     *
     * @param name variable name
     * @param type variable type
     * @param start from where the variable is valid, if this is null,
     * it is valid from the start
     * @param end until where the variable is valid, if this is null,
     * it is valid to the end
     * @return new local variable object
     * @see LocalVariable
     */
    public LocalVariableGen addLocalVariable(String name, Type type, InstructionHandle start, InstructionHandle end) {
        return addLocalVariable(name, type, max_locals, start, end);
    }

    /**
     * Remove a local variable, its slot will not be reused, if you do not use addLocalVariable
     * with an explicit index argument.
     */
    public void removeLocalVariable(LocalVariableGen l) {
        variable_vec.remove(l);
    }

    /**
     * Remove all local variables.
     */
    public void removeLocalVariables() {
        variable_vec.clear();
    }

    /**
     * Sort local variables by index
     */
    private static final void sort(LocalVariableGen[] vars, int l, int r) {
        int i = l, j = r;
        int m = vars[(l + r) / 2].getIndex();
        LocalVariableGen h;

        do {
            while (vars[i].getIndex() < m)
                i++;
            while (m < vars[j].getIndex())
                j--;

            if (i <= j) {
                h = vars[i];
                vars[i] = vars[j];
                vars[j] = h; // Swap elements
                i++;
                j--;
            }
        } while (i <= j);

        if (l < j)
            sort(vars, l, j);
        if (i < r)
            sort(vars, i, r);
    }

    /*
     * If the range of the variable has not been set yet, it will be set to be valid from
     * the start to the end of the instruction list.
     *
     * @return array of declared local variables sorted by index
     */
    public LocalVariableGen[] getLocalVariables() {
        int size = variable_vec.size();
        LocalVariableGen[] lg = new LocalVariableGen[size];
        variable_vec.toArray(lg);

        for (int i = 0; i < size; i++) {
            if (lg[i].getStart() == null)
                lg[i].setStart(il.getStart());

            if (lg[i].getEnd() == null)
                lg[i].setEnd(il.getEnd());
        }

        if (size > 1)
            sort(lg, 0, size - 1);

        return lg;
    }

    /**
     * @return `LocalVariableTable' attribute of all the local variables of this method.
     */
    public LocalVariableTable getLocalVariableTable(ConstantPoolGen cp) {
        LocalVariableGen[] lg = getLocalVariables();
        int size = lg.length;
        LocalVariable[] lv = new LocalVariable[size];

        for (int i = 0; i < size; i++)
            lv[i] = lg[i].getLocalVariable(cp);

        return new LocalVariableTable(cp.addUtf8("LocalVariableTable"), 2 + lv.length * 10, lv, cp.getConstantPool());
    }

    /**
     * Give an instruction a line number corresponding to the source code line.
     *
     * @param ih instruction to tag
     * @return new line number object
     * @see LineNumber
     */
    public LineNumberGen addLineNumber(InstructionHandle ih, int src_line) {
        LineNumberGen l = new LineNumberGen(ih, src_line);
        line_number_vec.add(l);
        return l;
    }

    /**
     * Remove a line number.
     */
    public void removeLineNumber(LineNumberGen l) {
        line_number_vec.remove(l);
    }

    /**
     * Remove all line numbers.
     */
    public void removeLineNumbers() {
        line_number_vec.clear();
    }

    /*
     * @return array of line numbers
     */
    public LineNumberGen[] getLineNumbers() {
        LineNumberGen[] lg = new LineNumberGen[line_number_vec.size()];
        line_number_vec.toArray(lg);
        return lg;
    }

    /**
     * @return `LineNumberTable' attribute of all the local variables of this method.
     */
    public LineNumberTable getLineNumberTable(ConstantPoolGen cp) {
        int size = line_number_vec.size();
        LineNumber[] ln = new LineNumber[size];

        try {
            for (int i = 0; i < size; i++)
                ln[i] = ((LineNumberGen) line_number_vec.get(i)).getLineNumber();
        } catch (ArrayIndexOutOfBoundsException e) {
        } // Never occurs

        return new LineNumberTable(cp.addUtf8("LineNumberTable"), 2 + ln.length * 4, ln, cp.getConstantPool());
    }

    /**
     * Add an exception handler, i.e., specify region where a handler is active and an
     * instruction where the actual handling is done.
     *
     * @param start_pc Start of region (inclusive)
     * @param end_pc End of region (inclusive)
     * @param handler_pc Where handling is done
     * @param catch_type class type of handled exception or null if any
     * exception is handled
     * @return new exception handler object
     */
    public CodeExceptionGen addExceptionHandler(InstructionHandle start_pc, InstructionHandle end_pc, InstructionHandle handler_pc, ObjectType catch_type) {
        if ((start_pc == null) || (end_pc == null) || (handler_pc == null))
            throw new ClassGenException("Exception handler target is null instruction");

        CodeExceptionGen c = new CodeExceptionGen(start_pc, end_pc, handler_pc, catch_type);
        exception_vec.add(c);
        return c;
    }

    /**
     * Remove an exception handler.
     */
    public void removeExceptionHandler(CodeExceptionGen c) {
        exception_vec.remove(c);
    }

    /**
     * Remove all line numbers.
     */
    public void removeExceptionHandlers() {
        exception_vec.clear();
    }

    /*
     * @return array of declared exception handlers
     */
    public CodeExceptionGen[] getExceptionHandlers() {
        CodeExceptionGen[] cg = new CodeExceptionGen[exception_vec.size()];
        exception_vec.toArray(cg);
        return cg;
    }

    /**
     * @return code exceptions for `Code' attribute
     */
    private CodeException[] getCodeExceptions() {
        int size = exception_vec.size();
        CodeException[] c_exc = new CodeException[size];

        try {
            for (int i = 0; i < size; i++) {
                CodeExceptionGen c = (CodeExceptionGen) exception_vec.get(i);
                c_exc[i] = c.getCodeException(cp);
            }
        } catch (ArrayIndexOutOfBoundsException e) {
        }

        return c_exc;
    }

    /**
     * Add an exception possibly thrown by this method.
     *
     * @param class_name (fully qualified) name of exception
     */
    public void addException(String class_name) {
        throws_vec.add(class_name);
    }

    /**
     * Remove an exception.
     */
    public void removeException(String c) {
        throws_vec.remove(c);
    }

    /**
     * Remove all exceptions.
     */
    public void removeExceptions() {
        throws_vec.clear();
    }

    /*
     * @return array of thrown exceptions
     */
    public String[] getExceptions() {
        String[] e = new String[throws_vec.size()];
        throws_vec.toArray(e);
        return e;
    }

    /**
     * @return `Exceptions' attribute of all the exceptions thrown by this method.
     */
    private ExceptionTable getExceptionTable(ConstantPoolGen cp) {
        int size = throws_vec.size();
        int[] ex = new int[size];

        try {
            for (int i = 0; i < size; i++)
                ex[i] = cp.addClass((String) throws_vec.get(i));
        } catch (ArrayIndexOutOfBoundsException e) {
        }

        return new ExceptionTable(cp.addUtf8("Exceptions"), 2 + 2 * size, ex, cp.getConstantPool());
    }

    /**
     * Add an attribute to the code. Currently, the JVM knows about the
     * LineNumberTable, LocalVariableTable and StackMap attributes,
     * where the former two will be generated automatically and the
     * latter is used for the MIDP only. Other attributes will be
     * ignored by the JVM but do no harm.
     *
     * @param a attribute to be added
     */
    public void addCodeAttribute(Attribute a) {
        code_attrs_vec.add(a);
    }

    /**
     * Remove a code attribute.
     */
    public void removeCodeAttribute(Attribute a) {
        code_attrs_vec.remove(a);
    }

    /**
     * Remove all code attributes.
     */
    public void removeCodeAttributes() {
        code_attrs_vec.clear();
    }

    /**
     * @return all attributes of this method.
     */
    public Attribute[] getCodeAttributes() {
        Attribute[] attributes = new Attribute[code_attrs_vec.size()];
        code_attrs_vec.toArray(attributes);
        return attributes;
    }

    /**
     * Get method object. Never forget to call setMaxStack() or setMaxStack(max), respectively,
     * before calling this method (the same applies for max locals).
     *
     * @return method object
     */
    public Method getMethod() {
        String signature = getSignature();
        int name_index = cp.addUtf8(name);
        int signature_index = cp.addUtf8(signature);

        /* Also updates positions of instructions, i.e., their indices
         */
        byte[] byte_code = null;

        if (il != null)
            byte_code = il.getByteCode();

        LineNumberTable lnt = null;
        LocalVariableTable lvt = null;

        /* Create LocalVariableTable and LineNumberTable attributes (for debuggers, e.g.)
         */
        if ((variable_vec.size() > 0) && !strip_attributes)
            addCodeAttribute(lvt = getLocalVariableTable(cp));

        if ((line_number_vec.size() > 0) && !strip_attributes)
            addCodeAttribute(lnt = getLineNumberTable(cp));

        Attribute[] code_attrs = getCodeAttributes();

        /* Each attribute causes 6 additional header bytes
         */
        int attrs_len = 0;
        for (int i = 0; i < code_attrs.length; i++)
            attrs_len += (code_attrs[i].getLength() + 6);

        CodeException[] c_exc = getCodeExceptions();
        int exc_len = c_exc.length * 8; // Every entry takes 8 bytes

        Code code = null;

        if ((il != null) && !isAbstract()) {
            // Remove any stale code attribute
            Attribute[] attributes = getAttributes();
            for (int i = 0; i < attributes.length; i++) {
                Attribute a = attributes[i];

                if (a instanceof Code)
                    removeAttribute(a);
            }

            code = new Code(cp.addUtf8("Code"), 8 + byte_code.length + // prologue byte code
            2 + exc_len + // exceptions
            2 + attrs_len, // attributes
            max_stack, max_locals, byte_code, c_exc, code_attrs, cp.getConstantPool());

            addAttribute(code);
        }

        ExceptionTable et = null;

        if (throws_vec.size() > 0)
            addAttribute(et = getExceptionTable(cp)); // Add `Exceptions' if there are "throws" clauses

        Method m = new Method(access_flags, name_index, signature_index, getAttributes(), cp.getConstantPool());

        // Undo effects of adding attributes
        if (lvt != null)
            removeCodeAttribute(lvt);
        if (lnt != null)
            removeCodeAttribute(lnt);
        if (code != null)
            removeAttribute(code);
        if (et != null)
            removeAttribute(et);

        return m;
    }

    /**
     * Remove all NOPs from the instruction list (if possible) and update every
     * object refering to them, i.e., branch instructions, local variables and
     * exception handlers.
     */
    public void removeNOPs() {
        if (il != null) {
            InstructionHandle next;
            /* Check branch instructions.
             */
            for (InstructionHandle ih = il.getStart(); ih != null; ih = next) {
                next = ih.next;

                if ((next != null) && (ih.getInstruction() instanceof NOP)) {
                    try {
                        il.delete(ih);
                    } catch (TargetLostException e) {
                        InstructionHandle[] targets = e.getTargets();

                        for (int i = 0; i < targets.length; i++) {
                            InstructionTargeter[] targeters = targets[i].getTargeters();

                            for (int j = 0; j < targeters.length; j++)
                                targeters[j].updateTarget(targets[i], next);
                        }
                    }
                }
            }
        }
    }

    /**
     * Set maximum number of local variables.
     */
    public void setMaxLocals(int m) {
        max_locals = m;
    }

    public int getMaxLocals() {
        return max_locals;
    }

    /**
     * Set maximum stack size for this method.
     */
    public void setMaxStack(int m) {
        max_stack = m;
    }

    public int getMaxStack() {
        return max_stack;
    }

    /** @return class that contains this method
     */
    public String getClassName() {
        return class_name;
    }

    public void setClassName(String class_name) {
        this.class_name = class_name;
    }

    public void setReturnType(Type return_type) {
        setType(return_type);
    }

    public Type getReturnType() {
        return getType();
    }

    public void setArgumentTypes(Type[] arg_types) {
        this.arg_types = arg_types;
    }

    public Type[] getArgumentTypes() {
        return (Type[]) arg_types.clone();
    }

    public void setArgumentType(int i, Type type) {
        arg_types[i] = type;
    }

    public Type getArgumentType(int i) {
        return arg_types[i];
    }

    public void setArgumentNames(String[] arg_names) {
        this.arg_names = arg_names;
    }

    public String[] getArgumentNames() {
        return (String[]) arg_names.clone();
    }

    public void setArgumentName(int i, String name) {
        arg_names[i] = name;
    }

    public String getArgumentName(int i) {
        return arg_names[i];
    }

    public InstructionList getInstructionList() {
        return il;
    }

    public void setInstructionList(InstructionList il) {
        this.il = il;
    }

    public String getSignature() {
        return Type.getMethodSignature(type, arg_types);
    }

    /**
     * Computes max. stack size by performing control flow analysis.
     */
    public void setMaxStack() {
        if (il != null)
            max_stack = getMaxStack(cp, il, getExceptionHandlers());
        else
            max_stack = 0;
    }

    /**
     * Compute maximum number of local variables.
     */
    public void setMaxLocals() {
        if (il != null) {
            int max = isStatic() ? 0 : 1;

            if (arg_types != null)
                for (int i = 0; i < arg_types.length; i++)
                    max += arg_types[i].getSize();

            for (InstructionHandle ih = il.getStart(); ih != null; ih = ih.getNext()) {
                Instruction ins = ih.getInstruction();

                if ((ins instanceof LocalVariableInstruction) || (ins instanceof RET) || (ins instanceof IINC)) {
                    int index = ((IndexedInstruction) ins).getIndex() + ((TypedInstruction) ins).getType(cp).getSize();

                    if (index > max)
                        max = index;
                }
            }

            max_locals = max;
        } else
            max_locals = 0;
    }

    /** Do not/Do produce attributes code attributesLineNumberTable and
     * LocalVariableTable, like javac -O
     */
    public void stripAttributes(boolean flag) {
        strip_attributes = flag;
    }

    static final class BranchTarget {
        InstructionHandle target;
        int stackDepth;

        BranchTarget(InstructionHandle target, int stackDepth) {
            this.target = target;
            this.stackDepth = stackDepth;
        }
    }

    static final class BranchStack {
        Stack branchTargets = new Stack();
        Hashtable visitedTargets = new Hashtable();

        public void push(InstructionHandle target, int stackDepth) {
            if (visited(target))
                return;

            branchTargets.push(visit(target, stackDepth));
        }

        public BranchTarget pop() {
            if (!branchTargets.empty()) {
                BranchTarget bt = (BranchTarget) branchTargets.pop();
                return bt;
            }

            return null;
        }

        private final BranchTarget visit(InstructionHandle target, int stackDepth) {
            BranchTarget bt = new BranchTarget(target, stackDepth);
            visitedTargets.put(target, bt);

            return bt;
        }

        private final boolean visited(InstructionHandle target) {
            return (visitedTargets.get(target) != null);
        }
    }

    /**
     * Computes stack usage of an instruction list by performing control flow analysis.
     *
     * @return maximum stack depth used by method
     */
    public static int getMaxStack(ConstantPoolGen cp, InstructionList il, CodeExceptionGen[] et) {
        BranchStack branchTargets = new BranchStack();

        /* Initially, populate the branch stack with the exception
         * handlers, because these aren't (necessarily) branched to
         * explicitly. in each case, the stack will have depth 1,
         * containing the exception object.
         */
        for (int i = 0; i < et.length; i++) {
            InstructionHandle handler_pc = et[i].getHandlerPC();
            if (handler_pc != null)
                branchTargets.push(handler_pc, 1);
        }

        int stackDepth = 0, maxStackDepth = 0;
        InstructionHandle ih = il.getStart();

        while (ih != null) {
            Instruction instruction = ih.getInstruction();
            short opcode = instruction.getOpcode();
            int delta = instruction.produceStack(cp) - instruction.consumeStack(cp);

            stackDepth += delta;
            if (stackDepth > maxStackDepth)
                maxStackDepth = stackDepth;

            // choose the next instruction based on whether current is a branch.
            if (instruction instanceof BranchInstruction) {
                BranchInstruction branch = (BranchInstruction) instruction;
                if (instruction instanceof Select) {
                    // explore all of the select's targets. the default target is handled below.
                    Select select = (Select) branch;
                    InstructionHandle[] targets = select.getTargets();
                    for (int i = 0; i < targets.length; i++)
                        branchTargets.push(targets[i], stackDepth);
                    // nothing to fall through to.
                    ih = null;
                } else if (!(branch instanceof IfInstruction)) {
                    // if an instruction that comes back to following PC,
                    // push next instruction, with stack depth reduced by 1.
                    if (opcode == Constants.JSR || opcode == Constants.JSR_W)
                        branchTargets.push(ih.getNext(), stackDepth - 1);
                    ih = null;
                }
                // for all branches, the target of the branch is pushed on the branch stack.
                // conditional branches have a fall through case, selects don't, and
                // jsr/jsr_w return to the next instruction.
                branchTargets.push(branch.getTarget(), stackDepth);
            } else {
                // check for instructions that terminate the method.
                if (opcode == Constants.ATHROW || opcode == Constants.RET || (opcode >= Constants.IRETURN && opcode <= Constants.RETURN))
                    ih = null;
            }
            // normal case, go to the next instruction.
            if (ih != null)
                ih = ih.getNext();
            // if we have no more instructions, see if there are any deferred branches to explore.
            if (ih == null) {
                BranchTarget bt = branchTargets.pop();
                if (bt != null) {
                    ih = bt.target;
                    stackDepth = bt.stackDepth;
                }
            }
        }

        return maxStackDepth;
    }

    private ArrayList observers;

    /** Add observer for this object.
     */
    public void addObserver(MethodObserver o) {
        if (observers == null)
            observers = new ArrayList();

        observers.add(o);
    }

    /** Remove observer for this object.
     */
    public void removeObserver(MethodObserver o) {
        if (observers != null)
            observers.remove(o);
    }

    /** Call notify() method on all observers. This method is not called
     * automatically whenever the state has changed, but has to be
     * called by the user after he has finished editing the object.
     */
    public void update() {
        if (observers != null)
            for (Iterator e = observers.iterator(); e.hasNext();)
                ((MethodObserver) e.next()).notify(this);
    }

    /**
     * Return string representation close to declaration format,
     * `public static void _main(String[]) throws IOException', e.g.
     *
     * @return String representation of the method.
     */
    public final String toString() {
        String access = Utility.accessToString(access_flags);
        String signature = Type.getMethodSignature(type, arg_types);

        signature = Utility.methodSignatureToString(signature, name, access, true, getLocalVariableTable(cp));

        StringBuffer buf = new StringBuffer(signature);

        if (throws_vec.size() > 0) {
            for (Iterator e = throws_vec.iterator(); e.hasNext();)
                buf.append("\n\t\tthrows " + e.next());
        }

        return buf.toString();
    }

    /** @return deep copy of this method
     */
    public MethodGen copy(String class_name, ConstantPoolGen cp) {
        Method m = ((MethodGen) clone()).getMethod();
        MethodGen mg = new MethodGen(m, class_name, this.cp);

        if (this.cp != cp) {
            mg.setConstantPool(cp);
            mg.getInstructionList().replaceConstantPool(this.cp, cp);
        }

        return mg;
    }
}
